Developer CD Series 1995 June: Reference Library/Dev.CD Jun 95/Dev.CD Jun 95.toast/Technical Documentation/Mac Tech Notes (DocViewer)/PR • Printing/PR10-Printing Loop/PR10-Printing Loop

Text File | 1994-07-24 | 77.2 KB | 400 lines | [ONLN/HLX2]

PR 10 - A Printing Loop That Cares…
Printing    ernigan & Pete “Luke” Alexander    October 1990
This Technical Note discusses opening and closing the Printing Manager with calls to _PrOpen and _PrClose as well as how to handle errors at print time.
Changes since October 1990:  Added code in both versions to handle printing documents larger than 128 pages.
Introduction
At one time, Apple recommended that developers call _PrOpen at the beginning of their application and _PrClose at the end, before returning to the Finder.  This recommendation was in the ancient past when an application only had to deal with a single printer driver.
As more printer drivers became available, it became important for an application to consider the presence of other applications and how opening and closing the printer driver affected them.  The user could open the Chooser at any time and change the current printer driver without the current application’s knowledge.  If an application followed the old philosophy and a user changed the current printer driver while running the application, the next time the user attempted to print, the wrong driver would be open, the Printing Manager would not be able to find the necessary resources, and the user would get an error.
The Current Recommendation
DTS currently recommends that applications open and close the printer driver each time the application uses the Printing Manager.
MPW Pascal
*------ PrintStuff ----------------------------------------------------------------*}
{**
 **    PrintStuff will call all of the necessary Print Manager calls to print
 **    a document.  It checks PrError() after each Print Manager call.  If an
 **    error is found, all of the Print Manager open calls (i.e., PrOpen,
 **    PrOpenDoc...) will have a corresponding close call before the error
 **    is posted to the user.  You want to use this approach to make sure the
 **    Print Manager closes properly and all temporary memory is released.
 **}
PROCEDURE PrintStuff;
VAR
  copies,
  firstPage,
  lastPage,
  loop,
  numberOfCopies,
  pageNumber,
  printmgrsResFile,
  realNumberOfPagesInDoc  : Integer;
  PrintError              : LongInt;
  oldPort                 : GrafPtr;
  thePrRecHdl             : THPrint;
  thePrPort               : TPPrPort;
  theStatus               : TPrStatus;
BEGIN
  GetPort(oldPort);
  {**
      UnLoadTheWorld will swap out ALL unneeded code segments and data that are NOT
      required
      during print time. Your print code must be a separate code segment.
  **}
  UnLoadTheWorld;
  thePrRecHdl := THPrint(NewHandle(SIZEOF(TPrint)));
  IF (MemError = noErr) AND (thePrRecHdl <> NIL) THEN
    BEGIN
      PrOpen;
        IF (PrError = noErr) THEN
          BEGIN
            {**
                Save the current resource file (i.e. the printer driver's)
                so the driver will not lose its resources upon return from
                the pIdleProc.
             **}
            printmgrsResFile := CurResFile;
            PrintDefault(thePrRecHdl);
            IF (PrError = noErr) THEN
              BEGIN
                IF (PrStlDialog(thePrRecHdl)) THEN
                  BEGIN
                    {**
                        DetermineNumberOfPagesinDoc determines the number of
                        pages contained in the document by comparing the size of
                        the document with rPage from the TPrInfo record (IM II-150).
                        It returns the number of pages required to print the
                        document for the currently selected printer.
                     **}
                    realNumberOfPagesinDoc := DetermineNumberOfPagesinDoc
                                                  (thePrRecHdl^^.prInfo.rPage);
                    IF (PrJobDialog(thePrRecHdl)) THEN
                      BEGIN
                        {**
                            Get the number of copies of the document that the
                            user wants printed from iCopies of the TPrJob record
                            (IM II-151).
                         **}
                        numberOfCopies := thePrRecHdl^^.prJob.iCopies;
                        {**
                            Get the first and last pages of the document that
                            were requested to be printed by the user from iFstPage
                            and iLastPage from the TPrJob record (IM II-151).
                         **}
                        firstPage := thePrRecHdl^^.prJob.iFstPage;
                        lastPage := thePrRecHdl^^.prJob.iLstPage;
                        {**
                            Print "all" pages in the print loop
                         **}
                        thePrRecHdl^^.prJob.iFstPage := 1;
                        thePrRecHdl^^.prJob.iLstPage := 9999;
                        {**
                            Determine the "real" number of pages contained in
                            the document.  Without this test, you would print
                            9999 pages.
                         **}
                        IF (realNumberOfPagesinDoc < lastPage) THEN
                          lastPage := realNumberOfPagesinDoc;
                        PrintingStatusDialog := GetNewDialog(257, NIL, POINTER(-1));

                        {**
                            Print the number of copies of document requested by the
                  user
                            from the Print Job Dialog.
                         **}
                        For copies := 1 To numberOfCopies Do
                          BEGIN
                            {**
                                Install a pointer to your pIdle proc in my print record.
                             **}
                             thePrRecHdl^^.prJob.pIdleProc := @checkMyPrintDialogButton;
                            {**
                                Restore the resource file to the printer driver's.
                             **}
                            UseResFile(printmgrsResFile);
                            thePrPort := PrOpenDoc(thePrRecHdl, NIL, NIL);
                            IF (PrError = noErr) THEN
                              BEGIN
                                {**
                                    Print the range of pages of the document requested
                                    by the user from the Print Job Dialog.
                                 **}
                                pageNumber := firstPage;
                                WHILE ((pageNumber <= lastPage) AND (PrError = noErr)) DO
                                  BEGIN

                    { **
                    If we've crossed a 128-page boundary,
                    close the current print file, send it
                    to the printer if necessary, and open a
                    new document.
                    ** }

                    IF (pageNumber - firstPage) MOD iPFMaxPgs = 0 THEN
                                      BEGIN
                                        IF pageNumber <> firstPage THEN
                                          BEGIN
                                            PrCloseDoc(thePrPort);
                                            IF (thePrRecHdl^^.prJob.bJDocLoop = bSpoolLoop)
                                              AND (PrError = noErr) THEN
                                              PrPicFile(thePrRecHdl, NIL,NIL, NIL, theStatus);
                                            thePrPort := PrOpenDoc(thePrRecHdl, NIL, NIL);
                                          END;
                                        END;
                      PrOpenPage(thePrPort, NIL);
                                      IF (PrError = noErr) THEN
                                        BEGIN
                                          {**
                                              rPage (IM II-150) is the printable
                                              area for the currently selected printer.
                                              By passing the current enables your app to use
                          the same routine to draw to the screen and the
                          printer's GrafPort.
                                           **}
                                          DrawStuff (thePrRecHdl^^.prInfo.rPage,
                                                     GrafPtr (thePrPort),
                                                     pageNumber);
                                        END;
                                      PrClosePage(thePrPort);
                                      pageNumber := pageNumber + 1;
                                  END;  {**  End pagenumber loop  **}
                              END;
                            PrCloseDoc(thePrPort);
                          END;  {**  End copies loop  **}
                          {**
                              The printing job is being canceled by the request of
                              the user from the Print Style Dialog or the Print Job
                              Dialog.  PrError will be set to iPrAbort to tell the
                              Print Manager to abort the current printing job.
                           **}
                      END
                        ELSE
                      PrSetError(iPrAbort);   {**  Cancel from the job dialog  **}
                  END
                    ELSE
                  PrSetError(iPrAbort);   {**  Cancel from the style dialog  **}
              END;
          END;
    IF (thePrRecHdl^^.prJob.bJDocLoop = bSpoolLoop) and (PrError = noErr) THEN
      PrPicFile(thePrRecHdl, NIL, NIL, NIL, theStatus);
    {**
        Grab the printing error -- once you close the Printing Manager, PrError doesn't return
        a valid result anymore.
     **}
    PrintError := PrError;
    PrClose;
    {**
        You do not want to report any printing errors until you have fallen
        through the printing loop. This will make sure that ALL of the Print
        Manager's open calls have their corresponding close calls, thereby
        enabling the Print Manager to close properly and that all temporary
        memory allocations are released.
     **}
    IF (PrintError <> noErr) THEN
      PostPrintingErrors (PrintError);
    END;
  IF (thePrRecHdl <> NIL) THEN
    DisposHandle(Handle (thePrRecHdl));
  IF (PrintingStatusDialog <> NIL) THEN
    DisposDialog(PrintingStatusDialog);
  SetPort(oldPort);
END;  {**  PrintStuff  **}
MPW C
/*------ PrintStuff ----------------------------------------------------------------*/
 **
 **    PrintStuff will call all of the necessary Print Manager calls to print
 **    a document. It checks PrError() after each Print Manager call. If an error
 **    is found, all of the Print Manager open calls (i.e., PrOpen, PrOpenDoc...)
 **    will have a corresponding close call before the error is posted to the user.
 **    You want to use this approach to make sure the Print Manager closes properly
 **    and all temporary memory is released.
 **/
void PrintStuff ()
{
  GrafPtr      oldPort;
  short        copies,
               firstPage,
               lastPage,
               numberOfCopies,
               printmgrsResFile,
               realNumberOfPagesinDoc,
               pageNumber,
               PrintError;
  THPrint      thePrRecHdl;
  TPPrPort     thePrPort;
  TPrStatus    theStatus;
  GetPort(&oldPort);
 /**
     UnLoadTheWorld will swap out ALL unneeded code segments and data that
     are NOT required during print time. Your print code must be a separate
     code segment.
  **/
  UnLoadTheWorld ();
  thePrRecHdl = (THPrint)  NewHandle (sizeof (TPrint));
 /**
     Check to make sure that the memory manager did not produce an error
     when it allocated the print record handle and make sure it did not pass
     back a nil handle.
  **/
  if (MemError() == noErr && thePrRecHdl != nil)
    {
      PrOpen();
      if (PrError() == noErr)
        {
         /**
              Save the current resource file (i.e. the printer driver's) so
              the driver will not lose its resources upon return from the pIdleProc.
          **/
          printmgrsResFile = CurResFile();
          PrintDefault(thePrRecHdl);
          if (PrError() == noErr)
            {
              if (PrStlDialog(thePrRecHdl))
                {
                 /**
                     DetermineNumberOfPagesinDoc determines the number of pages
                     contained in the document by comparing the size of the document
                     with rPage from the TPrInfo record (IM II-150). It returns the
                     number of pages required to print the document for the                          currently selected printer.
                  **/
                  realNumberOfPagesinDoc = DetermineNumberOfPagesinDoc
                                             ((**thePrRecHdl).prInfo.rPage);
                  if (PrJobDialog(thePrRecHdl))
                    {
                     /**
                          Get the number of copies of the document that the user
                          wants printed from iCopies of the TPrJob record (IM II-151).
                      **/
                      numberOfCopies = (**thePrRecHdl).prJob.iCopies;
                       /**
                           Get the first and last pages of the document that
                           were requested to be printed by the user from iFstPage
                           and iLastPage from the TPrJob record (IM II-151).
                        **/
                      firstPage = (**thePrRecHdl).prJob.iFstPage;
                      lastPage = (**thePrRecHdl).prJob.iLstPage;
                       /**
                           Print "all" pages in the print loop
                        **/
                      (**thePrRecHdl).prJob.iFstPage = 1;
                      (**thePrRecHdl).prJob.iLstPage = 9999;
                       /**
                           Determine the "real" number of pages contained in the                        document. Without this test, you would print 9999 pages.
                        **/
                      if (realNumberOfPagesinDoc < lastPage)
                        lastPage = realNumberOfPagesinDoc;
                      PrintingStatusDialog = GetNewDialog(257, nil, (WindowPtr) -1);
                       /**
                           Print the number of copies of the document
                           requested by the user from the Print Job Dialog.
                        **/
                      for (copies = 1; copies <= numberOfCopies; copies++)
                        {
                         /**
                             Install a pointer to your pIdle proc in my print record.
                          **/
                          (**thePrRecHdl).prJob.pIdleProc = checkMyPrintDialogButton;
                         /**
                             Restore the resource file to the printer driver's.
                          **/
                          UseResFile(printmgrsResFile);
                          thePrPort = PrOpenDoc(thePrRecHdl, nil, nil);
                          if (PrError() == noErr)
                            {
                             /**
                                 Print the range of pages of the document
                                 requested by the user from the Print Job Dialog.
                              **/
                              pageNumber = firstPage;
                              while (pageNumber <= lastPage && PrError() == noErr)
                                {

                     /**
                       If we've crossed a 128-page boundary,
                       close the current print file, send it
                       to the printer if necessary, and open a
                       new document.
                     **/

                     if ((pageNumber - firstPage) % iPFMaxPgs == 0)
                       {
                         if (pageNumber != firstPage)
                           {
                             PrCloseDoc(thePrPort);
                             if (((**thePrRecHdl).prJob.bJDocLoop ==
                                             bSpoolLoop) && (PrError() == noErr))
                                             PrPicFile(thePrRecHdl, nil, nil, nil,
                                                       &theStatus);
                             thePrPort = PrOpenDoc(thePrRecHdl, nil,
                                                                nil);
                                         }
                                     }
                     PrOpenPage(thePrPort, nil);
                                  if (PrError() == noErr)
                                    {
                                     /**
                                         rPage (IM II-150) is the printable area
                                         for the currently selected printer. By                          passing the current port to the draw                              routine, enables your app to use the same                          routine to draw to the screen and the                          printer's GrafPort.
                                      **/
                                      DrawStuff ((**thePrRecHdl).prInfo.rPage,
                                                 (GrafPtr) thePrPort, pageNumber);
                                    }
                                  PrClosePage(thePrPort);
                                  pageNumber++;
                                }  /**  End pageNumber loop  **/
                            }
                          PrCloseDoc(thePrPort);
                        } /**  End copies loop  **/
                    }
                   /**
                       The printing job is being canceled by the request of the
                       user from the Print Style Dialog or the Print Job Dialog.
                       PrError will be set to PrAbort to tell the Print Manager to
                       abort the current printing job.
                    **/
                  else
                    PrSetError (iPrAbort);   /**  cancel from the job dialog  **/
                }
              else
                PrSetError (iPrAbort);   /**  cancel from the style dialog  **/
            }
        }
      if (((**thePrRecHdl).prJob.bJDocLoop == bSpoolLoop) && (PrError() == noErr))
        PrPicFile(thePrRecHdl, nil, nil, nil, &theStatus);
       /**
           Grab the printing error -- once you close the Printing Manager, PrError doesn't
       returna valid result anymore.
       **/
      PrintError = PrError();
      PrClose();
       /**
           You do not want to report any printing errors until you have fallen
           through the printing loop. This will make sure that ALL of the Print
           Manager's open calls have their corresponding close calls, thereby
           enabling the Print Manager to close properly and that all temporary
           memory allocations are released.
        **/
      if (PrintError != noErr)
        PostPrintingErrors (PrintError);
    }
  if (thePrRecHdl != nil)
    DisposHandle((Handle) thePrRecHdl);
  if (PrintingStatusDialog != nil)
    DisposDialog(PrintingStatusDialog);
  SetPort(oldPort);
}  /** PrintStuff **/
Checking And Handling Printing Errors
An application should always check for error conditions while printing by calling PrError.  PrError returns errors from the Printing Manager (and some AppleTalk and OS errors) that occur during printing.
As the example code demonstrates, an application should call PrError after each call to a Printing Manager function or procedure.  By consistently checking PrError after each call, the application is able to catch any errors created at print time and report them to a user via a dialog box in a clean and graceful manner.
The following section outlines some general error-handling guidelines.
•    You should avoid calling PrError within your pIdle procedure; errors that occur while it is executing are usually temporary and serve only as internal flags for communication within the printer driver—they are not intended for the application.  If you absolutely must call PrError within your idle procedure, and an error occurs, never abort printing within the idle procedure itself.  Wait until the last called printing procedure returns, then check to see if the error still remains.  Attempting to abort printing within an idle procedure is a guarantee of certain death.
•    Upon detecting an error after the completion of a printing routine, stop drawing at that point, and proceed to the next procedure to close any previously made open calls.  For example, if you detect an error after calling PrOpenDoc, skip to the next PrCloseDoc.  Or, if you get an error after calling PrOpenPage, skip to the next PrClosePage and PrCloseDoc.  Remember that if you have called PrOpen, then you must call the corresponding PrClose to ensure that printing closes properly and all temporary memory allocations are released and returned to the heap.
•    Do not display any alert or dialog boxes to report an error until the end of the printing loop.  Once at the end, check for the error again; if there is no error assume that printing completed normally.  If the error is still present, then you can alert the user.
    This technique is important for two reasons.  First, if you display a dialog box in the middle of the printing loop, it could cause errors that can terminate an otherwise normal job.  For example, if the printer is an AppleTalk printer, the connection can be terminated abnormally since the driver would be unable to respond to AppleTalk requests received from the printer while the dialog box was waiting for input from the user.  If the printer does not hear from the Macintosh with a short period of time (e.g., 30 seconds), it times out, assuming that the Macintosh is no longer there, which results in a prematurely broken connection causing another error to which the application must respond.
    In addition, the driver may have already displayed its own dialog box in response to an error.  In this instance, the driver posts an error to let the application know that something went wrong and it should abort printing.  For example, when the LaserWriter driver detects that the Laser Prep version which has been downloaded to the LaserWriter is different than that with which the user is trying to print, it displays the appropriate dialog box informing the user of the situation and giving him the option of reinitializing the printer.  If the user chooses to cancel printing, the driver posts an error to let the application know that it needs to abort, but since the driver has already taken care of the error by displaying a dialog box, the error is reset to zero before the printing loop is complete.  The application should check for the error again at the end of the printing loop, and if it still indicates an error, the application can then display the appropriate dialog box.
•    If using PrGeneral, be prepared to receive the following errors:  NoSuchRsl, OpNotImpl, and resNotFound.  In all three cases, the application should be prepared to continue to print without using the features of that particular opcode.
    However, in the case of the resNotFound error, it means the current printer driver does not support PrGeneral.  This lack of support should not be a problem for an application, but it needs to be prepared to deal with this error.  If you receive a resNotFound error from PrError, clear the error with a call to PrSetError(0); otherwise, PrError might still contain this error the next time you check it, which would prevent your application from printing.
Canceling or Pausing the Printing Process
If you install a procedure for handling requests to cancel printing, with an option to pause the printing process, beware of timeout problems when printing to the LaserWriter.  Communication between the Macintosh and the LaserWriter must be maintained to prevent a job or a wait timeout.  If there is no communication for a period of time (over two minutes), the printer times out and the print job terminates due to a wait  timeout.  Or, if the print job requires more than three minutes to print, the print job terminates due to a job timeout.  Since, there is no good method to determine to what type of printer an application is printing, it is probably a good idea to document the possibility of a LaserWriter timing out for a user who chooses to select “pause” for over two minutes.
Error Messages Created In Print Land…
The Printing Manager reports the error messages covered in this section.  If an error that does not belong to the Printing Manager occurs, the Printing Manager puts it into low memory, where it can be retrieved with a call to PrError, and terminates the printing loop, if necessary.  As already documented, if you encounter an error in the middle of a printing loop, do not jump out; fall through the loop and let the Printing Manager terminate properly.
Error Code    Constant    Description
    0    noErr    No error
    128    iPrAbort    Abort the printing process
            (Command-period)
    -1    iPrSavePFil    Problem saving print file
    -17    controlErr    Unimplemented Control call
    -27    iIOAbort    I/O problems
    -108    iMemFullErr    Not enough heap space
The following errors are specific to the LaserWriter family:
    -4101        Printer not found or closed
    -4100        Connection just closed
    -4099        Write request too big
    -4098        Request already active
    -4097        Bad connection refnum
    -4096        No free Connect Control Blocks (CCBs) available
    -8133        PostScript error occurred during transmission of data to printer.  Most often caused by a bug in the PostScript code being downloaded.
    -8132        Timeout occurred.  This error is returned when no data has been sent to the printer for two minutes.  Usually caused by extremely long imaging time.
    -8131        Printer not responding:  it may have been turned “off.”  This error occurs if a user turns off the LaserWriter in the middle of a print job.
The following errors are specific to PrGeneral:
    1    NoSuchRsl    Requested resolution is not supported
    2    OpNotImpl    Requested PrGeneral opcode not implemented in the current printer driver.
    -192    resNotfound    The current printer driver does not support PrGeneral.
The most common error encountered is -4101, which is generated if no LaserWriter is selected.  Since this error is so common, it is a good idea to display a dialog box requesting the user to select a printer from the Chooser when this error is encountered.
Further Reference:
•    Inside Macintosh, Volume II-145 & V-410, The Printing Manager
•    Technical Note M.IM.DevIndPrinting —
         Device-Independent Printing
•    d e v e l o p, July 1990, Issue 3, “Meet PrGeneral”
◊#ˇˇˇˇˇ#◊†Ç

6Zà#
    0Ià:µú9"Ç    ˇˇˇˇˇˇˇˇ#†ƒ°d
ONLNf
˛†å°d1drw2
…-
·
_ġˇˇˇˇˇ

è°ñ
x°ddrw2:
°ddrw2:$°d4drw2:





°öˇ˙ó@†ò,Times

.
R
…R
…+]INew Technical Notes†ô°ddrw2:°„
†ó°d1drw2
e
Ùġˇˇˇˇˇ

P°ñ
x°ddrw2:
°ddrw2:$°d4drw2:




°öˇ˚ÄE¿†ò
(Ç
ïDeveloper Support†ô°ddrw2:°„
†ó°d`drw2-
Ôˇˇˇˇˇˇ

K
Ô-
Z
 mmZ°d1drw2
 
¿
˙
Èˇˇˇˇˇˇ

K°ñ
x°ddrw2:
°ddrw2:$°d4drw2:
0



°öˇÙĆò
0(\
Ô
†ô°ddrw2:°„
†ó°d1drw2
Ô
Ê
˙
ˇˇˇˇˇˇ

°ñ
x°ddrw2:
°ddrw2:$°d4drw2:
    



°öˇ˝Ä†ò
    +&    
®†ô°ddrw2:°„
†ó°d1drw2
Â-
¯yˇˇˇˇˇˇ



°ñ
x°ddrw2:
°ddrw2:$°d4drw2:




°öˇ˚Ä%†ò
(a\    Macintosh†ô°ddrw2:°„
†ó†ç°ddrw2D†É

IR
.



°dONLNdu<à
y(¢Z#PR 10 - A Printing Loop That Cares…
°dONLNd$á<ìb*
Printing°dONLNd-áÑì
")Hernigan & Pete “Luke” Alexander°dONLNdMá
æì
˛(Ø
‹October 1990°dONLNdZü<´W(«ZThis °dONLNd_üW´
˛)OTechnical Note discusses opening and closing the Printing Manager with calls to,
Courier°dONLNdØ´<∑m(‘Z_PrOpen°dONLNd∂¨m∏Ñ)1 and °dONLNdª´Ñ∑º)_PrClose°dONLNd√¨º∏
ë)8/ as well as how to handle errors at print time.
°dONLNdÛ∏<ƒ·(‡ZChanges since October 1990:°dONLNd
∏·ƒ
F)•  Added code in both 
°dONLNd
#∏
Fƒ
˛)e%versions to handle printing documents

"◊W°dONLNd
Iƒ<–•(ÏZlarger than 128 pages."„W ˚X˚

°dONLNd
`È<¯è*(Introduction
°dONLNd
m
<

5*/At one time, Apple recommended that developers °dONLNd
ú

5

K)˘call °dONLNd
°

K

|)_PrOpen°dONLNd
®

|

˛)1 at the beginning of their
°dONLNd
√
<
à(
:Zapplication and °dONLNd
”
à
¿)L_PrClose°dONLNd
€
¿

ñ)8. at the end, before returning to the Finder.  °dONLNd    

ñ

˛)÷This recommendation°dONLNd
<
*
Ÿ(
FZZwas in the ancient past when an application only had to deal with a single printer driver.°dONLNdx
6<
B
∑*QAs more printer drivers became available, it became important for an application 
°dONLNd…
6
∑
B
˛(
^
’to consider the°dONLNdŸ
B<
N
t(
jZ?presence of other applications and how opening and closing the °dONLNd
B
t
N
˛(
j
íprinter driver affected them.°dONLNd7
N<
Z€(
vZ The user could open the Chooser 
°dONLNdW
N€
Z
˛)ü=at any time and change the current printer driver without the°dONLNdï
Z<
f
Í(
ÇZVcurrent application’s knowledge.  If an application followed the old philosophy and a °dONLNdÎ
Z
Í
f
˛(
Çuser°dONLNd
f<
r
(
éZ)changed the current printer driver while °dONLNd
f

r
˛)œ/running the application, the next time the user°dONLNdI
r<
~
ö(
öZIattempted to print, the wrong driver would be open, the Printing Manager 
°dONLNdí
r
ö
~
˛(
ö
∏would not be able to°dONLNdß
~<
ä
_(
¶Z>find the necessary resources, and the user would get an error.

°dONLNdÊ
¢<
±
*'The Current Recommendation

°dONLNd

Ω<
…
a*:DTS currently recommends that applications open and close °dONLNd;
Ω
a
…
π(
Â
the printer driver 
°dONLNdN
Ω
π
…
“)Xeach°dONLNdR
Ω
“
…
˛)     time the°dONLNd\
…<
’Ò(
ÒZ&application uses the Printing Manager.
°dONLNdÉ
·<
ÌÉ*
MPW Pascal
    °dONLNdé
˘<
÷*R*------ PrintStuff ---------------------------------------------------------------°dONLNd‡
˘
÷
€( 
Ù
-°dONLNd·<F(*Z*}°dONLNd‰
<K*
{**°dONLNdË<"K*
 **°dONLNdÏ`"
æ)$FPrintStuff will call all of the necessary Print Manager calls to print°dONLNd3!<,K(HZ **°dONLNd7!`,
æ)$Fa document.  It checks PrError() after each Print Manager call.  If an°dONLNd~+<6K(RZ **°dONLNdÇ+`6
™)$Berror is found, all of the Print Manager open calls (i.e., PrOpen,°dONLNd≈5<@K(\Z **°dONLNd…5`@
Ø)$CPrOpenDoc...) will have a corresponding close call before the error°dONLNd
?<JK(fZ **°dONLNd?`J
æ)$Fis posted to the user.  You want to use this approach to make sure the°dONLNdXI<TK(pZ **°dONLNd\I`T
Ø)$CPrint Manager closes properly and all temporary memory is released.°dONLNd†S<^P(zZ **}°dONLNd•g<r•*PROCEDURE PrintStuff;°dONLNdª{<ÜK*VAR ∂X∂

*,#PR 10 - A Printing Loop That Cares…(Œ
ˇ
1) of 12(‰ZM.PR.PrintLoopˇ°¿
Ù%%DSIDICT:_cv
currentdict /bu known {bu}if
userdict /_cv known not{userdict /_cv 30 dict put}if
_cv begin
/bdf{bind def}bind def
currentscreen/cs exch def/ca exch def/cf exch def
/setcmykcolor where{/setcmykcolor get /cvcmyk exch def}{/cvcmyk{1 sub 4 1 roll 3{3 index add neg dup 0 lt{pop 0}if 3 1 roll}repeat setrgbcolor pop}bdf }ifelse
/ss{//cf //ca //cs setscreen}bdf
/stg{ss setgray}bdf
/strgb{ss setrgbcolor}bdf
/stcmyk{ss cvcmyk}bdf
/min1{dup 0 eq{pop 1}if}bdf
end
currentdict /bn known {bn}if
†øà◊#ˇˇˇˇˇ#◊

IR,Times

.+6-Macintosh Technical Notes /4/
˘,
Courier
    °dONLNd(E*      copies,°dONLNd
'2T*
  firstPage,°dONLNd1<O*
  lastPage,°dONLNd#;F;*
  loop,°dONLNd+EPm*
  numberOfCopies,°dONLNd=OZY*

  pageNumber,°dONLNdKYdw*
  printmgrsResFile,°dONLNd_cnÃ*
$  realNumberOfPagesInDoc  : Integer;°dONLNdÑmxÃ*
$  PrintError              : LongInt;°dONLNd©wÇÃ*
$  oldPort                 : GrafPtr;°dONLNdŒÅåÃ*
$  thePrRecHdl             : THPrint;°dONLNdÛãñ—*
%  thePrPort               : TPPrPort;°dONLNd
ï†÷*
&  theStatus               : TPrStatus;°dONLNd
@©¥1*BEGIN°dONLNd
F≥æw*
  GetPort(oldPort);°dONLNd
Z«“1*  {**°dONLNd
`—‹
∑*
S      UnLoadTheWorld will swap out ALL unneeded code segments and data that are NOT°dONLNd
¥€Ê^*
      required°dONLNd
√Â
Ö*
I      during print time. Your print code must be a separate code segment.°dONLNd
Ô˙1*
  **}°dONLNd˘
m*
  UnLoadTheWorld;°dONLNd%



*4  thePrRecHdl := THPrint(NewHandle(SIZEOF(TPrint)));°dONLNdZ
!
,
!*5  IF (MemError = noErr) AND (thePrRecHdl <> NIL) THEN°dONLNdê
+
6E*
        BEGIN°dONLNdö
5
@Y*

      PrOpen;°dONLNd®
?
JΩ*
!        IF (PrError = noErr) THEN°dONLNd 
I
Tc*
          BEGIN°dONLNd⁄
S
^c*
            {**°dONLNdÍ
]
h
ä*
J                Save the current resource file (i.e. the printer driver's)°dONLNd5
g
r
ä*
J                so the driver will not lose its resources upon return from°dONLNdÄ
q
|Æ*
                the pIdleProc.°dONLNdü
{
Üh*
             **}°dONLNd∞
Ö
êÔ*
+            printmgrsResFile := CurResFile;°dONLNd‹
è
ö÷*
&            PrintDefault(thePrRecHdl);°dONLNd
£
Æ—*%            IF (PrError = noErr) THEN°dONLNd)
≠
∏w*
              BEGIN°dONLNd=
∑
¬
*
2                IF (PrStlDialog(thePrRecHdl)) THEN°dONLNdp
¡
Ãã*
                  BEGIN°dONLNdà
À
֋*
                    {**°dONLNd†
’
‡
î*
L                        DetermineNumberOfPagesinDoc determines the number of°dONLNdÌ
fl
Í
®*
P                        pages contained in the document by comparing the size of°dONLNd>
È
Ù
º*
T                        the document with rPage from the TPrInfo record (IM II-150).°dONLNdì
Û
˛
î*
L                        It returns the number of pages required to print the°dONLNd‡
˝
l*
D                        document for the currently selected printer.°dONLNd%ê*
                     **}°dONLNd>&
Ö*I                    realNumberOfPagesinDoc := DetermineNumberOfPagesinDoc°dONLNdà%0
£*
O                                                  (thePrRecHdl^^.prInfo.rPage);°dONLNdÿ9D
&*6                    IF (PrJobDialog(thePrRecHdl)) THEN°dONLNdCNü*
                      BEGIN°dONLNd,MXü*
                        {**°dONLNdHWb
ô*
M                            Get the number of copies of the document that the°dONLNdñal
®*
P                            user wants printed from iCopies of the TPrJob record°dONLNdÁkv‡*
(                            (IM II-151).°dONLNduħ*
                         **} ∂4∂
˘

*2
2) of 12(Œ
Z#PR 10 - A Printing Loop That Cares…+YM.PR.PrintLoopˇƒ◊#ˇˇˇˇˇ#◊

IR,Times

.+Z-Developer Support Center(-
ÊOctober 1990 /X/,
Courier
    °dONLNd<"
ö(>ZF                        numberOfCopies := thePrRecHdl^^.prJob.iCopies;°dONLNdG+<6√*                        {**°dONLNdc5<@
Ω*
M                            Get the first and last pages of the document that°dONLNd±?<J
÷*
R                            were requested to be printed by the user from iFstPage°dONLNd
I<T
Ω*
M                            and iLastPage from the TPrJob record (IM II-151).°dONLNd
RS<^»*
                         **}°dONLNd
og<r
Ü*B                        firstPage := thePrRecHdl^^.prJob.iFstPage;°dONLNd
≤q<|
Å*
A                        lastPage := thePrRecHdl^^.prJob.iLstPage;°dONLNd
ÙÖ<ê√*                        {**°dONLNdè<ö
w*
?                            Print "all" pages in the print loop°dONLNdPô<§»*
                         **}°dONLNdm≠<∏
^*:                        thePrRecHdl^^.prJob.iFstPage := 1;°dONLNd®∑<¬
m*
=                        thePrRecHdl^^.prJob.iLstPage := 9999;°dONLNdÊÀ<÷√*                        {**°dONLNd’<‡
Ω*
M                            Determine the "real" number of pages contained in°dONLNdPfl<Í
Ω*
M                            the document.  Without this test, you would print°dONLNdûÈ<Ùˇ*
'                            9999 pages.°dONLNdΔÛ<˛»*
                         **}°dONLNd„
<

ã*C                        IF (realNumberOfPagesinDoc < lastPage) THEN°dONLNd'
<

m*
=                          lastPage := realNumberOfPagesinDoc;°dONLNde
%<
0
‡*T                        PrintingStatusDialog := GetNewDialog(257, NIL, POINTER(-1));°dONLNd”
9<
D√*                        {**°dONLNdÔ
C<
N
€*
S                            Print the number of copies of document requested by the°dONLNdF
M®
X⁄+l

      user°dONLNdQ
W<
b
J(
~Z6                            from the Print Job Dialog.°dONLNdà
a<
l»*
                         **}°dONLNd•
u<
Ä
h*<                        For copies := 1 To numberOfCopies Do°dONLNd‚
<
ä◊*
                          BEGIN°dONLNd
ì<
û◊*                            {**°dONLNd"
ù<
®
Ã*
P                                Install a pointer to your pIdle proc in my print°dONLNds
ß<
≤_*
record.°dONLNd{
±<
º‹*
                              **}°dONLNdú
ª<
Δ
m*
=                             thePrRecHdl^^.prJob.pIdleProc :=°dONLNd⁄
≈<
–æ*
@checkMyPrintDialogButton;°dONLNdı
Ÿ<
‰◊*                            {**°dONLNd
„<
Ó
÷*
R                                Restore the resource file to the printer driver's.°dONLNdh
Ì<
¯‹*
                              **}°dONLNdâ
˜<
Y*
9                            UseResFile(printmgrsResFile);°dONLNd√<
Æ*J                            thePrPort := PrOpenDoc(thePrRecHdl, NIL, NIL);°dONLNd<*
E*5                            IF (PrError = noErr) THEN°dONLNdD)<4Î*
#                              BEGIN°dONLNdh3<>Î*
#                                {**°dONLNdå=<H
∏*
L                                    Print the range of pages of the document°dONLNdŸG<Ri*
    requested°dONLNd„Q<\
Æ*
J                                    by the user from the Print Job Dialog.°dONLNd    .[<f*
$                                 **}°dONLNd    Se<p
T*
8                                pageNumber := firstPage;°dONLNd    åo<z
¬*
N                                WHILE ((pageNumber <= lastPage) AND (PrError =°dONLNd    €y<Ñn*

noErr)) DO ∂X∂

*.#PR 10 - A Printing Loop That Cares…(Œ
ˇ
3) of 12(‰ZM.PR.PrintLoopˇ◊#ˇˇˇˇˇ#◊

IR,Times

.+6-Macintosh Technical Notes /4/
˘,
Courier
    °dONLNd(€*'                                  BEGIN°dONLNd41®<–+ê    { **"P3    °dONLNdB;ÃF
Ö+$
%If we've crossed a 128-page boundary,"Z3    °dONLNdmEÃP
Ö*
%close the current print file, send it"d3    °dONLNdòOÃZ
è*
'to the printer if necessary, and open a"n3    °dONLNd≈YÃd

*

new document."x3    °dONLNd◊c®n–(äΔ    ** }"Ç3    "å3    °dONLNdÏw®Ç
∂*6    IF (pageNumber - firstPage) MOD iPFMaxPgs = 0 THEN"ñ3    °dONLNd
#ÅåÔ(®6+                                      BEGIN"†3    °dONLNd
Oãñ
{*
G                                        IF pageNumber <> firstPage THEN"™3    °dONLNd
óï†
*
/                                          BEGIN"¥3    °dONLNd
«ü™
b*
B                                            PrCloseDoc(thePrPort);"æ3    °dONLNd
©¥
£*
O                                            IF (thePrRecHdl^^.prJob.bJDocLoop ="»3    °dONLNdZ≥æO*
bSpoolLoop)"“3    °dONLNdfΩ»
Ä*
H                                              AND (PrError = noErr) THEN"‹3    °dONLNdØ«“
≤*
R                                              PrPicFile(thePrRecHdl, NIL,NIL, NIL,"Ê3    °dONLNd—‹O*
theStatus);"3    °dONLNd€Ê
º*
T                                            thePrPort := PrOpenDoc(thePrRecHdl, NIL,"˙3    °dONLNdcÂ1*
NIL);"
3    °dONLNdiÔ˙˛*
.                                          END;"
3    °dONLNdò˘
Ù*
,                                        END;"
3    °dONLNd…

®

M+ê!      PrOpenPage(thePrPort, NIL);°dONLNdÎ
!
,
S(
H6?                                      IF (PrError = noErr) THEN°dONLNd+
+
6˘*
-                                        BEGIN°dONLNdY
5
@˘*
-                                          {**°dONLNdá
?
J
®*
P                                              rPage (IM II-150) is the printable°dONLNdÿ
I
T
ô*
M                                              area for the currently selected°dONLNd&
S
^@*
printer.°dONLNd/
]
h
≠*
Q                                              By passing the current enables your°dONLNdÅ
g
rJ*

app to use°dONLNdë
qÃ
|
º+¥
0      the same routine to draw to the screen and°dONLNd¬
{
Ü'(
¢6the°dONLNdÀ
ÖÃ
ê
I+¥
      printer's GrafPort.°dONLNdÂ
è
ö˛(
∂6.                                           **}°dONLNd
£
Æ
®*P                                          DrawStuff (thePrRecHdl^^.prInfo.rPage,°dONLNdf
≠
∏
Ö*
I                                                     GrafPtr (thePrPort),°dONLNd±
∑
¬
]*
A                                                     pageNumber);°dONLNdÛ
¡
ÃÙ*
,                                        END;°dONLNd 
À
÷
I*
=                                      PrClosePage(thePrPort);°dONLNd^
’
‡
g*
C                                      pageNumber := pageNumber + 1;°dONLNd¢
fl
Í
q*
E                                  END;  {**  End pagenumber loop  **}°dONLNdË
È
Ù¬*
"                              END;°dONLNd
Û
˛
*
2                            PrCloseDoc(thePrPort);°dONLNd>
˝
5*
9                          END;  {**  End copies loop  **}°dONLNdx©*                          {**°dONLNdñ&
≤*
R                              The printing job is being canceled by the request of°dONLNdÈ%0
∑*
S                              the user from the Print Style Dialog or the Print Job°dONLNd    =/:
≤*
R                              Dialog.  PrError will be set to iPrAbort to tell the°dONLNd    ê9D
û*
N                              Print Manager to abort the current printing job.°dONLNd    flCNÆ*
                           **}°dONLNd    ˛MXï*
                      END°dONLNd
Wb§*
                        ELSE°dONLNd
5al
≤*
R                      PrSetError(iPrAbort);   {**  Cancel from the job dialog  **}°dONLNd
àkvÅ*
                  END°dONLNd
ûuÄê*
                    ELSE°dONLNd
∑ä
®*
P                  PrSetError(iPrAbort);   {**  Cancel from the style dialog  **} ∂4∂
˘

*(
4) of 12(Œ
Z#PR 10 - A Printing Loop That Cares…+YM.PR.PrintLoopˇ
x◊#ˇˇˇˇˇ#◊

IR,Times

.+Z-Developer Support Center(-
ÊOctober 1990 /X/,
Courier
    °dONLNd<"ñ(>Z              END;°dONLNd!<,Ç*
          END;°dONLNd"+<6
¬*
N    IF (thePrRecHdl^^.prJob.bJDocLoop = bSpoolLoop) and (PrError = noErr) THEN°dONLNdq5<@
O*
7      PrPicFile(thePrRecHdl, NIL, NIL, NIL, theStatus);°dONLNd©I<T_*    {**"hW    °dONLNd±S<^
«*
O        Grab the printing error -- once you close the Printing Manager, PrError"rW    °dONLNd

]<hÇ*
doesn't return"|W    °dONLNd
g<r◊*
        a valid result anymore."ÜW    °dONLNd
0q<|d*
     **}"êW    °dONLNd
9Ö<êæ*    PrintError := PrError;°dONLNd
Tô<§x*    PrClose;°dONLNd
a∑<¬_*    {**°dONLNd
i¡<Ã
≥*
K        You do not want to report any printing errors until you have fallen°dONLNd
µÀ<÷
∏*
L        through the printing loop. This will make sure that ALL of the Print°dONLNd’<‡
Æ*
J        Manager's open calls have their corresponding close calls, thereby°dONLNdMfl<Í
≥*
K        enabling the Print Manager to close properly and that all temporary°dONLNdôÈ<Ù
*
(        memory allocations are released.°dONLNd¬Û<˛d*
     **}°dONLNdÀ
<
·*!    IF (PrintError <> noErr) THEN°dONLNdÌ
<
˙*
&      PostPrintingErrors (PrintError);°dONLNd
%<
0d*    END;°dONLNd
9<
D“*  IF (thePrRecHdl <> NIL) THEN°dONLNd=
C<
Nˇ*
'    DisposHandle(Handle (thePrRecHdl));°dONLNde
W<
bˇ*'  IF (PrintingStatusDialog <> NIL) THEN°dONLNdé
a<
lˇ*
'    DisposDialog(PrintingStatusDialog);°dONLNd∂
u<
Äõ*  SetPort(oldPort);°dONLNd 
<
äæ*
END;  {**  PrintStuff  **}

°dONLNdÂ
ï<
°h*MPW C
    °dONLNdÎ
≠<
∏
€*S/*------ PrintStuff ---------------------------------------------------------------°dONLNd>
≠
€
∏
‡(
‘
˘
-°dONLNd?
∑<
¬F(
fiZ*/°dONLNdB
¡<
ÃK*
 **°dONLNdF
À<
÷
Ω*
M **    PrintStuff will call all of the necessary Print Manager calls to print°dONLNdî
’<
‡
—*
Q **    a document. It checks PrError() after each Print Manager call. If an error°dONLNdÊ
fl<
Í
—*
Q **    is found, all of the Print Manager open calls (i.e., PrOpen, PrOpenDoc...)°dONLNd8
È<
Ù
€*
S **    will have a corresponding close call before the error is posted to the user.°dONLNdå
Û<
˛
€*
S **    You want to use this approach to make sure the Print Manager closes properly°dONLNd‡
˝<
*
, **    and all temporary memory is released.°dONLNd
<P*
 **/°dONLNd<&ñ*void PrintStuff ()°dONLNd%%<0A*

{°dONLNd'/<:Ø*
  GrafPtr      oldPort;°dONLNd?9<D™*
  short        copies,°dONLNdVC<Nπ*
               firstPage,°dONLNdpM<X¥*
               lastPage,°dONLNdâW<b“*
               numberOfCopies,°dONLNd®a<l‹*
                printmgrsResFile,°dONLNd…k<v˙*
&               realNumberOfPagesinDoc,°dONLNdu<Äæ*
               pageNumber,°dONLNd<äæ*
               PrintError; ∂X∂

*(#PR 10 - A Printing Loop That Cares…(Œ
ˇ
5) of 12(‰ZM.PR.PrintLoopˇä◊#ˇˇˇˇˇ#◊

IR,Times

.+6-Macintosh Technical Notes /4/
˘,
Courier
    °dONLNd(ü*  THPrint      thePrRecHdl;°dONLNd'2ï*
  TPPrPort     thePrPort;°dONLNd61<ï*
  TPrStatus    theStatus;°dONLNdPEP|*  GetPort(&oldPort);°dONLNdeYd,* /**°dONLNdjcn
ä*
J     UnLoadTheWorld will swap out ALL unneeded code segments and data that°dONLNdµmx
è*
K     are NOT required during print time. Your print code must be a separate°dONLNd

wÇr*
     code segment.°dONLNd
Åå1*
  **/°dONLNd
ï†|*  UnLoadTheWorld ();°dONLNd
/ü™
+*
7  thePrRecHdl = (THPrint)  NewHandle (sizeof (TPrint));°dONLNd
g≥æ,* /**°dONLNd
lΩ»
Ä*
H     Check to make sure that the memory manager did not produce an error°dONLNd
µ«“
î*
L     when it allocated the print record handle and make sure it did not pass°dONLNd—‹ã*
     back a nil handle.°dONLNd€Ê1*
  **/°dONLNd Ô˙
*0  if (MemError() == noErr && thePrRecHdl != nil)°dONLNdQ˘
1*
    {°dONLNdW

c*
      PrOpen();°dONLNdg

"©*      if (PrError() == noErr)°dONLNdÖ
!
,E*
            {°dONLNdè
+
6T*
         /**°dONLNdú
5
@
è*
K              Save the current resource file (i.e. the printer driver's) so°dONLNdË
?
J
º*
T              the driver will not lose its resources upon return from the pIdleProc.°dONLNd=
I
TY*

          **/°dONLNdK
S
^Í*
*          printmgrsResFile = CurResFile();°dONLNdv
]
hÃ*
$          PrintDefault(thePrRecHdl);°dONLNdõ
q
|Ω*!          if (PrError() == noErr)°dONLNdΩ
{
ÜY*

            {°dONLNdÀ
Ö
êÔ*
+              if (PrStlDialog(thePrRecHdl))°dONLNd˜
è
öm*
                {°dONLNd    
ô
§|*
                 /**°dONLNd
£
Æ
£*
O                     DetermineNumberOfPagesinDoc determines the number of pages°dONLNdn
≠
∏
º*
T                     contained in the document by comparing the size of the document°dONLNd√
∑
¬
∑*
S                     with rPage from the TPrInfo record (IM II-150). It returns the°dONLNd
¡
Ã
î*
L                     number of pages required to print the document for the °dONLNdf
À`
÷
(+H
(             currently selected printer.°dONLNdè
’
‡Å(
¸6                  **/°dONLNd•
È
Ù
v*F                  realNumberOfPagesinDoc = DetermineNumberOfPagesinDoc°dONLNdÏ
Û
˛
î*
L                                             ((**thePrRecHdl).prInfo.rPage);°dONLNd9
*/                  if (PrJobDialog(thePrRecHdl))°dONLNdjÅ*
                    {°dONLNdÄ&ê*
                     /**°dONLNdô%0
®*
P                          Get the number of copies of the document that the user°dONLNdÎ/:
®*
P                          wants printed from iCopies of the TPrJob record (IM II°dONLNd;/
®:
≠(V
Δ
-°dONLNd<9D1(`6151).°dONLNdBCNï*
                      **/°dONLNd\Wb
q*E                      numberOfCopies = (**thePrRecHdl).prJob.iCopies;°dONLNd¢kvö*                       /**°dONLNdΩuÄ
î*
L                           Get the first and last pages of the document that°dONLNd
ä
≠*
Q                           were requested to be printed by the user from iFstPage ∂4∂
˘

*(
6) of 12(Œ
Z#PR 10 - A Printing Loop That Cares…+YM.PR.PrintLoopˇJ◊#ˇˇˇˇˇ#◊

IR,Times

.+Z-Developer Support Center(-
ÊOctober 1990 /X/,
Courier
    °dONLNd<"
∏(>ZL                           and iLastPage from the TPrJob record (IM II-151).°dONLNdM!<,√*
                        **/°dONLNdi5<@
Å*A                      firstPage = (**thePrRecHdl).prJob.iFstPage;°dONLNd´?<J
|*
@                      lastPage = (**thePrRecHdl).prJob.iLstPage;°dONLNdÏS<^æ*                       /**°dONLNd
]<h
r*
>                           Print "all" pages in the print loop°dONLNd
Fg<r√*
                        **/°dONLNd
b{<Ü
Y*9                      (**thePrRecHdl).prJob.iFstPage = 1;°dONLNd
úÖ<ê
h*
<                      (**thePrRecHdl).prJob.iLstPage = 9999;°dONLNd
Ÿô<§æ*                       /**°dONLNd
Ù£<Æ
—*
Q                           Determine the "real" number of pages contained in the °dONLNdH≠®∏
‘+l
<           document. Without this test, you would print 9999°dONLNdÖ∑<¬Z(fiZpages.°dONLNdå¡<Ã√*
                        **/°dONLNd®’<‡
h*<                      if (realNumberOfPagesinDoc < lastPage)°dONLNdÊfl<Í
^*
:                        lastPage = realNumberOfPagesinDoc;°dONLNd!Û<˛
‡*T                      PrintingStatusDialog = GetNewDialog(257, nil, (WindowPtr) -1);°dONLNdv
<
æ*                       /**°dONLNdë
<

ï*
E                           Print the number of copies of the document°dONLNd◊
<
&
≥*
K                           requested by the user from the Print Job Dialog.°dONLNd#
%<
0√*
                        **/°dONLNd?
/<
:
Æ*
J                      for (copies = 1; copies <= numberOfCopies; copies++)°dONLNdä
9<
Dπ*
                        {°dONLNd§
C<
N»*
                         /**°dONLNd¡
M<
X
Ω*
M                             Install a pointer to your pIdle proc in my print°dONLNd
W<
b_*
record.°dONLNd
a<
lÕ*
                          **/°dONLNd5
k<
v
c*
;                          (**thePrRecHdl).prJob.pIdleProc =°dONLNdq
u<
Äπ*
checkMyPrintDialogButton;°dONLNdã
â<
î»*                         /**°dONLNd®
ì<
û
«*
O                             Restore the resource file to the printer driver's.°dONLNd¯
ù<
®Õ*
                          **/°dONLNd
±<
º
O*7                          UseResFile(printmgrsResFile);°dONLNdN
ª<
Δ
ü*
G                          thePrPort = PrOpenDoc(thePrRecHdl, nil, nil);°dONLNdñ
œ<
⁄
1*1                          if (PrError() == noErr)°dONLNd»
Ÿ<
‰Õ*
                            {°dONLNdÊ
Ì<
¯‹*                              /**°dONLNd
˜<
©*
I                                 Print the range of pages of the document°dONLNdR
<
—*
Q                                 requested by the user from the Print Job Dialog.°dONLNd§<·*
!                              **/°dONLNdΔ< 
E*
5                              pageNumber = firstPage;°dONLNd¸<*
÷*
R                              while (pageNumber <= lastPage && PrError() == noErr)°dONLNdO)<4·*
!                                {°dONLNdò=ÃHÙ+ê     /**"\W    °dONLNd¶GR
∏+$
(   If we've crossed a 128-page boundary,"fW    °dONLNd‘Q\
∏*
(   close the current print file, send it"pW    °dONLNd    [f
¬*
*   to the printer if necessary, and open a"zW    °dONLNd    2ep
@*
   new document."ÑW    °dONLNd    GoÃzÙ(ñÍ     **/"éW    "òW     ∂X∂

(ŒZ#PR 10 - A Printing Loop That Cares…(Œ
ˇ
7) of 12(‰ZM.PR.PrintLoopˇD◊#ˇˇˇˇˇ#◊

IR,Times

.+6-Macintosh Technical Notes /4/
˘,
Courier
    °dONLNd®(
ß+ê3     if ((pageNumber - firstPage) % iPFMaxPgs == 0)"<3    °dONLNd8'®2–*
       {"F3    °dONLNdE1®<
a*
%         if (pageNumber != firstPage)"P3    °dONLNdo;®F‰*
           {"Z3    °dONLNdÄE®P
W*
#             PrCloseDoc(thePrPort);"d3    °dONLNd®O®Z
¨*
4             if (((**thePrRecHdl).prJob.bJDocLoop =="n3    °dONLNd›Yd
≠(Ä6Q                                             bSpoolLoop) && (PrError() == noErr))"x3    °dONLNd
/cn
≤*
R                                             PrPicFile(thePrRecHdl, nil, nil, nil,"Ç3    °dONLNd
Çmx
g*
C                                                       &theStatus);"å3    °dONLNd
 w®Ç
¨+ê
4             thePrPort = PrOpenDoc(thePrRecHdl, nil,"ñ3    °dONLNd
ˇÅå
q(®6E                                                                nil);"†3    °dONLNdEãñÍ*
*                                         }"™3    °dONLNdpï†÷*
&                                     }"¥3    °dONLNdú©®¥
H+ê      PrOpenPage(thePrPort, nil);°dONLNdΩΩ»
5(‰69                                  if (PrError() == noErr)°dONLNd¯«“—*
%                                    {°dONLNd—‹‡*
(                                     /**°dONLNdG€Ê
®*
P                                         rPage (IM II-150) is the printable area°dONLNdòÂ
®*
P                                         for the currently selected printer. By °dONLNdÌÔÃ˙
û+¥
*     passing the current port to the draw °dONLNd˘Ã

∑*
/     routine, enables your app to use the same °dONLNdQ
Ã

£*
+     routine to draw to the screen and the °dONLNdÅ

Ã

D*
     printer's GrafPort.°dONLNdö

"Â(
>6)                                      **/°dONLNdƒ
!
,
û*
N                                      DrawStuff ((**thePrRecHdl).prInfo.rPage,°dONLNd
+
6
≤*
R                                                 (GrafPtr) thePrPort, pageNumber);°dONLNdg
5
@—*
%                                    }°dONLNdç
I
T
5*9                                  PrClosePage(thePrPort);°dONLNd«
S
^
*
/                                  pageNumber++;°dONLNd˜
]
h
X*
@                                }  /**  End pageNumber loop  **/°dONLNd8
g
r©*
                            }°dONLNdV
q
|
*
0                          PrCloseDoc(thePrPort);°dONLNdá
{
Ü
*
3                        } /**  End copies loop  **/°dONLNdª
Ö
êÅ*
                    }°dONLNd—
è
öÜ*
                   /**°dONLNdË
ô
§
£*
O                       The printing job is being canceled by the request of the°dONLNd8
£
Æ
®*
P                       user from the Print Style Dialog or the Print Job Dialog.°dONLNdâ
≠
∏
≤*
R                       PrError will be set to PrAbort to tell the Print Manager to°dONLNd‹
∑
¬
&*
6                       abort the current printing job.°dONLNd
¡
Ãã*
                    **/°dONLNd+
À
ֆ*
                  else°dONLNdB
’
‡
≠*
Q                    PrSetError (iPrAbort);   /**  cancel from the job dialog  **/°dONLNdî
fl
Ím*
                }°dONLNd¶
È
Ùr*
              else°dONLNdπ
Û
˛
£*
O                PrSetError (iPrAbort);   /**  cancel from the style dialog  **/°dONLNd

˝Y*

            }°dONLNd    E*
            }°dONLNd    "&
≤*R      if (((**thePrRecHdl).prJob.bJDocLoop == bSpoolLoop) && (PrError() == noErr))°dONLNd    u%0
:*
:        PrPicFile(thePrRecHdl, nil, nil, nil, &theStatus);°dONLNd    ∞9DJ*
       /**"X3    °dONLNd    ªCN
≤*
R           Grab the printing error -- once you close the Printing Manager, PrError"b3    °dONLNd
MX;*
doesn't"l3    °dONLNd
W<b‹+$
    returna valid result anymore."v3    °dONLNd
9alJ(à6
       **/"Ä3    °dONLNd
DuÄ©*      PrintError = PrError(); ∂4∂
˘

*2
8) of 12(Œ
Z#PR 10 - A Printing Loop That Cares…+YM.PR.PrintLoopˇ\◊#ˇˇˇˇˇ#◊

IR,Times

.+Z-Developer Support Center(-
ÊOctober 1990 /X/,
Courier
    °dONLNd<"å(>Z      PrClose();°dONLNd+<6n*
       /**°dONLNd5<@
¬*
N           You do not want to report any printing errors until you have fallen°dONLNdk?<J
«*
O           through the printing loop. This will make sure that ALL of the Print°dONLNdªI<T
Ω*
M           Manager's open calls have their corresponding close calls, thereby°dONLNd
    S<^
¬*
N           enabling the Print Manager to close properly and that all temporary°dONLNd
X]<h
*
+           memory allocations are released.°dONLNd
Ñg<rs*
        **/°dONLNd
êq<|“*
      if (PrintError != noErr)°dONLNd
∞{<Ü
*
(        PostPrintingErrors (PrintError);°dONLNd
ŸÖ<êU*
    }°dONLNd
flô<§π*  if (thePrRecHdl != nil)°dONLNd
˘£<Æˇ*
'    DisposHandle((Handle) thePrRecHdl);°dONLNd!∑<¬Ê*"  if (PrintingStatusDialog != nil)°dONLNdD¡<Ãˇ*
'    DisposDialog(PrintingStatusDialog);°dONLNdl’<‡õ*  SetPort(oldPort);°dONLNdÄfl<Í•*
}  /** PrintStuff **/ ∂X∂

(ŒZ#PR 10 - A Printing Loop That Cares…(Œ
ˇ
9) of 12(‰ZM.PR.PrintLoopˇ¨◊#ˇˇˇˇˇ#◊

IR,Times

.+6-Macintosh Technical Notes /4/
˘

°dONLNd)8
#*'%Checking And Handling Printing Errors

°dONLNd&EQ
•*RAn application should always check for error conditions while printing by calling ,
Courier°dONLNdxD
•P
÷(m
√PrError°dONLNdE
÷Q
⁄)1
.°dONLNdÇQ]I(z6PrError°dONLNdâRI^©)1 returns errors from 
°dONLNdûR©^
⁄)`<the Printing Manager (and some AppleTalk and OS errors) that°dONLNd€^jÄ(Ü6occur during printing.
°dONLNdÚwÉΔ*"As the example code demonstrates, °dONLNd
wΔÉ
H)Æan application should call °dONLNd
/v
HÇ
y)ÇPrError°dONLNd
6w
yÉ
⁄)1 after each call to a
°dONLNd
LÑê
_(¨6BPrinting Manager function or procedure.  By consistently checking °dONLNd
éÉ
_è
ê(¨
}PrError°dONLNd
ïÑ
êê
Δ)1 after each °dONLNd
°Ñ
Δê
⁄)6call,
°dONLNd
ßêú
’(∏6`the application is able to catch any errors created at print time and report them to a user via °dONLNdê
’ú
⁄(∏
Û
a°dONLNd    ú®‡(ƒ6*dialog box in a clean and graceful manner.°dONLNd4¥¿
f*FThe following section outlines some general error-handling guidelines.°dONLNd{Õ*Ÿ.+
•°dONLNd}Õ7Ÿ∏)
You should avoid calling °dONLNdñÃ∏ÿÈ)ÅPrError°dONLNdùÕÈŸ
)1 within °dONLNd•Õ
Ÿ
∂)(!your pIdle procedure; errors that°dONLNd«Ÿ7ÂÎ(

U(occur while it is executing are usually 
°dONLNdÔŸÎÂ
∂)¥*temporary and serve only as internal flags°dONLNdÂ7Òˆ(

U%for communication within the printer °dONLNd?ˆÒ
∂)ø$driver—they are not intended for the
°dONLNddÚ7˛˚(
U*application.  If you absolutely must call °dONLNdéÒ˚˝
,)ƒPrError°dONLNdïÚ
,˛
R)1 within °dONLNdùÚ
R˛
∂)&your idle procedure,
°dONLNd≤˛7


õ(
&ULand an error occurs, never abort printing within the idle procedure itself. °dONLNd˛˛
õ


∂(
&
π Wait°dONLNd

7
ë(
2Uuntil the last called 
°dONLNd

ë

∂)Z@printing procedure returns, then check to see if the error still°dONLNd[
7
"ƒ(
>Uremains.  Attempting to abort 
°dONLNdy
ƒ
"
∂)ç3printing within an idle procedure is a guarantee of°dONLNd≠
"7
.v(
JUcertain death.°dONLNdº
:*
F.(
bH
•°dONLNdæ
:7
Fê)
Upon detecting an 
°dONLNd–
:ê
F
∂)Y>error after the completion of a printing routine, stop drawing°dONLNd
F7
Rç(
nUat that point, and °dONLNd"
Fç
R
∂)V:proceed to the next procedure to close any previously made°dONLNd]
S7
_m(
{Uopen calls. 
°dONLNdi
Sm
_
[)63 For example, if you detect an error after calling °dONLNdú
R
[
^
ö)Ó    PrOpenDoc°dONLNd•
S
ö
_
∂)?, skip°dONLNd¨
`7
lC(
àUto 
°dONLNdØ
`C
lm)    the next °dONLNd∏
_m
k≥)*
PrCloseDoc°dONLNd¬
`≥
l
l)F).  Or, if you get an error after calling °dONLNdÎ
_
l
k
≤)π
PrOpenPage°dONLNdı
`
≤
l
∂)F
,°dONLNd˜
m7
yÇ(
ïUskip to the next °dONLNd
lÇ
xœ)KPrClosePage°dONLNd
mœ
yÊ)M and °dONLNd
lÊ
x
,)
PrCloseDoc°dONLNd"
m
,
y
ä)F.  Remember that if 
°dONLNd6
m
ä
y
∂)^you have°dONLNd?
z7
ÜV(
¢Ucalled °dONLNdF
yV
ÖÄ)PrOpen°dONLNdL
zÄ
Ü
?)*', then you must call the corresponding °dONLNds
y
?
Ö
p)øPrClose°dONLNdz
z
p
Ü
Å)1 to °dONLNd~
z
Å
Ü
∂)ensure that
°dONLNdä
Ü7
í
0(
ÆU2printing closes properly and all temporary memory °dONLNdº
Ü
0
í
∂)˘allocations are released and°dONLNdŸ
í7
ûò(
∫Ureturned to the heap.°dONLNdÔ
™*
∂.(
“H
•
°dONLNdÒ
™7
∂
:)
6Do not display any alert or dialog boxes to report an °dONLNd'
™
:
∂
∂(
“
Xerror until the end of the
°dONLNdB
∂7
©(
fiUprinting loop.  Once at °dONLNdZ
∂©
¬
∂)r8the end, check for the error again; if there is no error
°dONLNdì
¬7
Œ
`(
ÍU@assume that printing completed normally.  If the error is still °dONLNd”
¬
`
Œ
∂(
Í
~present, then you°dONLNdÂ
Œ7
ڊ(
ˆUcan alert the user.°dONLNd˙
Ê7
Ú
ó*MThis technique is important for two reasons.  First, if you display a dialog 
°dONLNdG
Ê
ó
Ú
∂(
µbox in°dONLNdN
Ú7
˛
´(UJthe middle of the printing loop, it could cause errors that can terminate °dONLNdò
Ú
´
˛
∂(
…an
°dONLNdõ
˛7

-(&U3otherwise normal job.  For example, if the printer °dONLNdŒ
˛
-

∂)ˆis an AppleTalk printer, the°dONLNdÎ
7
à(2UBconnection can be terminated abnormally since the driver would be °dONLNd    -

à
∂(2
¶    unable to
°dONLNd    77"a(>Urespond °dONLNd    ?a"
∂)*Dto AppleTalk requests received from the printer while the dialog box°dONLNd    Ñ"7.Û(JU%was waiting for input from the user. °dONLNd    ©"Û.
∂)º& If the printer does not hear from the°dONLNd    –.7:
    (VU-Macintosh with a short period of time (e.g., 
°dONLNd    ˝.
    :
∂)“#30 seconds), it times out, assuming°dONLNd
!:7F
=(bU5that the Macintosh is no longer there, which results °dONLNd
V:
=F
∂(b
[in a prematurely broken°dONLNd
nF7R
ã(nUGconnection causing another error to which the application must respond. ∂4∂
˘

(Œ610)
 of 12(Œ
Z#PR 10 - A Printing Loop That Cares…+YM.PR.PrintLoopˇé◊#ˇˇˇˇˇ#◊

IR,Times

.+Z-Developer Support Center(-
ÊOctober 1990 /X/
°dONLNd[#—(?yIn addition, the driver °dONLNd—#
⁄)v0may have already displayed its own dialog box in°dONLNdI#[/
Ã(KyJresponse to an error.  In this instance, the driver posts an error to let °dONLNdì#
Ã/
⁄(K
Íthe
°dONLNdó/[;
…(WyJapplication know that something went wrong and it should abort printing.  °dONLNd·/
…;
⁄(W
ÁFor°dONLNdÂ;[G∑(cyexample, when the 
°dONLNd˜;∑G
⁄)\<LaserWriter driver detects that the Laser Prep version which°dONLNd
4G[S
Δ(oyMhas been downloaded to the LaserWriter is different than that with which the 
°dONLNd
ÅG
ΔS
⁄(o
‰user°dONLNd
ÜS[_
*({y0is trying to print, it displays the appropriate 
°dONLNd
∂S
*_
⁄)œ$dialog box informing the user of the°dONLNd
€_[k¡(áysituation and giving °dONLNd
_¡k
⁄)f:him the option of reinitializing the printer.  If the user
°dONLNd+k[w
á(ìyAchooses to cancel printing, the driver posts an error to let the °dONLNdlk
áw
⁄(ì
•application know°dONLNd}w[Éx(üythat it 
°dONLNdÖwxÉ
⁄)Kneeds to abort, but since the driver has already taken care of the error by°dONLNd—É[è
å(´y?displaying a dialog box, the error is reset to zero before the °dONLNdÉ
åè
⁄(´
™printing loop is°dONLNd!è[õ
Ã(∑yJcomplete.  The application should check for the error again at the end of °dONLNdkè
Ãõ
⁄(∑
Íthe°dONLNdoõ[ß
C(√y7printing loop, and if it still indicates an error, the 
°dONLNd¶õ
Cß
⁄)Ë application can then display the°dONLNd«ß[≥…(œyappropriate dialog box.°dONLNdfl¿NÃR(Ël
•°dONLNd·¿[Ãë)
    If using ,
Courier°dONLNdÍøëÀ–)6    PrGeneral°dONLNdÛ¿–Ã
⁄)?., be prepared to receive the following errors:°dONLNd#Ã[ÿö(ıy    NoSuchRsl°dONLNd,ÕöŸ•)?, °dONLNd.Õÿ‰)    OpNotImpl°dONLNd7Õ‰Ÿ
)?, and °dONLNd=Ã
ÿ
T)#resNotFound°dONLNdHÕ
TŸ
ß)M.  In all three °dONLNdXÕ
ߟ
⁄)S
cases, the°dONLNdcŸ[¬(

yapplication should be 
°dONLNdyŸ¬Â
⁄)g;prepared to continue to print without using the features of°dONLNdµÂ[Òƒ(

ythat particular opcode.
°dONLNdŒ˛[

Ê*However, in the case of the °dONLNdÍ˝Ê
    
3)ãresNotFound°dONLNdı˛
3


Ç)M error, it means °dONLNd˛
Ç


⁄)Othe current printer°dONLNd
[
‘(
3ydriver does not support °dONLNd2

‘

)y    PrGeneral°dONLNd;



ƒ)?#.  This lack of support should not °dONLNd^

ƒ

⁄)±be a°dONLNdc
[
#
](
?y8problem for an application, but it needs to be prepared 
°dONLNdõ

]
#
⁄(
?
{to deal with this error.  If°dONLNd∏
$[
0ú(
Lyyou receive a °dONLNdΔ
#ú
/È)AresNotFound°dONLNd—
$È
0
 )M error from °dONLNd›
#
 
/
Q)7PrError°dONLNd‰
$
Q
0
¥)1, clear the error with 
°dONLNd˚
$
¥
0
⁄)c    a call to°dONLNd
0[
<∂(
Yy
PrSetError(0)°dONLNd
1∂
=Û)[
; otherwise, °dONLNd
0Û
<
$)=PrError°dONLNd&
1
$
=
ó)1 might still contain this °dONLNd@
1
ó
=
⁄)serror the next°dONLNdO
=[
I
´(
eyFtime you check it, which would prevent your application from printing.

°dONLNdñ
g<
v
U(
íZ)Canceling or Pausing the Printing Process
°dONLNd¿
Ç<
éµ*If you install a procedure 
°dONLNd€
ǵ
é
˛)yEfor handling requests to cancel printing, with an option to pause the°dONLNd!
é<
ö
@(
∂Z-printing process, beware of timeout problems °dONLNdN
é
@
ö
˛(
∂
^!when printing to the LaserWriter.
°dONLNdq
ö<
¶
{(
¬Z=Communication between the Macintosh and the LaserWriter must °dONLNdÆ
ö
{
¶
˛(
¬
ôbe maintained to prevent a°dONLNd…
¶<
≤
(
ŒZ^job or a wait timeout.  If there is no communication for a period of time (over two minutes), 
°dONLNd'
¶

≤
˛(
Œthe°dONLNd+
≤<
æ
≈(
⁄ZYprinter times out and the print job terminates due to a wait  timeout.  Or, if the print 
°dONLNdÑ
≤
≈
æ
˛(
⁄
„job requires°dONLNdë
æ<
 Ÿ(
ÊZ"more than three minutes to print, 
°dONLNd≥
æŸ
 
˛)ù?the print job terminates due to a job timeout.  Since, there is°dONLNdÛ
 <
÷
(
ÚZ,no good method to determine to what type of 
°dONLNd    
 

÷
˛)◊4printer an application is printing, it is probably a°dONLNd    T
÷<
‚
∞(
˛ZMgood idea to document the possibility of a LaserWriter timing out for a user °dONLNd    °
÷
∞
‚
˛(
˛
Œwho chooses to°dONLNd    ∞
‚<
ÓË(
Z$select “pause” for over two minutes.

°dONLNd    ’<
K*-%Error Messages Created In Print Land…
°dONLNd    ˚'<3
%*0The Printing Manager reports the error messages 
°dONLNd
+'
%3
˛)È/covered in this section.  If an error that does°dONLNd
[3<?s([Znot belong °dONLNd
f3s?
˛)7Mto the Printing Manager occurs, the Printing Manager puts it into low memory,°dONLNd
¥@<L
(hZ)where it can be retrieved with a call to °dONLNd
›?
K
=)–PrError°dONLNd
‰@
=L
G)1, °dONLNd
Ê@
GL
˛)
$and terminates the printing loop, if°dONLNdL<X
G(tZ7necessary.  As already documented, if you encounter an 
°dONLNdBL
GX
˛(t
e'error in the middle of a printing loop,°dONLNdjX<d
“(ÄZWdo not jump out; fall through the loop and let the Printing Manager terminate properly. ∂X∂

*N#PR 10 - A Printing Loop That Cares…(Œ
˙11)
 of 12(‰ZM.PR.PrintLoopˇN◊#ˇˇˇˇˇ#◊

IR,Times

.+6-Macintosh Technical Notes /4/
˘

°dONLNd<){+$
Error Code°dONLNdÑ)∂)HConstant°dONLNd)
1)lDescription HXH
ñ°dONLNd!+Z7`(Sx
0,
Courier°dONLNd#*Ñ6ß)*noErr°dONLNd)+7
)lNo error°dONLNd38ND`(`l128°dONLNd77ÑCº)6iPrAbort°dONLNd@8D
k)lAbort the printing process°dONLNd_DP
K*(Command-period)°dONLNdqQV]`(yt-1°dONLNdtPÑ\—).iPrSavePFil°dONLNdÄQ]
e)lProblem saving print file°dONLNdõ^Pj`(Ün-17°dONLNdü]Ñi )4
controlErr°dONLNd™^j
u)lUnimplemented Control call°dONLNdΔkPw`(ìn-27°dONLNd jÑvº)4iIOAbort°dONLNd”kw
.)lI/O problems°dONLNd·xJÑ`(†h-108°dONLNdÊwÑÉ—):iMemFullErr°dONLNdÚxÑ
^)lNot enough heap space £X£
ñ°dONLNd
ù©
.(≈6<The following errors are specific to the LaserWriter family:°dONLNd
F∂D¬`+,-4101°dONLNd
M∂¬
o)¨Printer not found or closed ‘X‘
˘°dONLNd
j¬DŒ`(Íb-4100°dONLNd
q¬Œ
[)¨Connection just closed°dONLNd
âŒD⁄`(ˆb-4099°dONLNd
êŒ⁄
S)¨Write request too big°dONLNd
ß⁄DÊ`(
b-4098°dONLNd
Æ⁄Ê
Y)¨Request already active°dONLNd
ΔÊDÚ`(
b-4097°dONLNd
ÕÊÚ
^)¨Bad connection refnum°dONLNd
‰ÚD˛`(
b-4096°dONLNd
ÎÚ˛
à)¨No free Connect Control     °dONLNdÚ
à˛
⁄)ò
Blocks (CCBs)°dONLNd˛


(
&
    available°dONLNd

D
`(
2b-8133
°dONLNd#



–)¨.PostScript error occurred during transmission °dONLNdQ


–

⁄)‡of°dONLNdT

"
Ã(
>
0data to printer.  Most often caused by a bug in 
°dONLNdÑ

Ã
"
⁄)‹the°dONLNdà
"
.
ò(
J
!PostScript code being downloaded.°dONLNd´
.D
:`(
Vb-8132
°dONLNd≤
.
:
L)¨Timeout occurred. °dONLNdƒ
.
L
:
⁄)\ This error is returned when°dONLNd·
:
F
1(
b
no data has °dONLNdÌ
:
1
F
⁄)A been sent to the printer for two°dONLNd
F
R
S(
n
minutes.  Usually °dONLNd 
F
S
R
⁄)ccaused by extremely long°dONLNd9
R
^
1(
z

imaging time.°dONLNdH
^D
j`(
Üb-8131°dONLNdO
^
j
)¨Printer 
°dONLNdW
^

j
⁄)#(not responding:  it may have been turned°dONLNdÄ
j
v
-(
í

“off.”  This °dONLNdç
j
-
v
⁄)=$error occurs if a user turns off the°dONLNd≤
v
Ç
¨(
û
)LaserWriter in the middle of a print job. 
°X
°
˘°dONLNd‹
ê
ú¡(
∏6%The following errors are specific to °dONLNd

è¡
õ
)©    PrGeneral°dONLNd

ê

ú
)?
:°dONLNd

™Z
∂`(
“x
1°dONLNd
©Ñ
µ√)*    NoSuchRsl°dONLNd
™
∂
¢)l%Requested resolution is not supported 
«X
«
Ÿ°dONLNd@
∑Z
√`(
flx
2°dONLNdB
∂Ñ
¬√)*    OpNotImpl
°dONLNdL
∑
√
.)l
Requested °dONLNdV
∂
.
¬
m)>    PrGeneral°dONLNd_
∑
m
√
∫)? opcode not°dONLNdk
√
œ
≤(
Î
*implemented in the current printer driver.°dONLNdó
–J
‹`(
¯h-192°dONLNdú
τ
€—):resNotfound°dONLNd®
–
‹
É)l The current printer driver does 
°dONLNd»
–
É
‹
∫)ìnot support°dONLNd‘
‹
Ë
/(
    PrGeneral°dONLNd›
›
/
È
3)?
. X
Ÿ°dONLNdfl
±(*6TThe most common error encountered is -4101, which is generated if no LaserWriter is 
°dONLNd3
±
⁄(*
œ    selected.°dONLNd>|(66Since this error is so 
°dONLNdU|
⁄)dHcommon, it is a good idea to display a dialog box requesting the user to°dONLNdû&
H(B6Aselect a printer from the Chooser when this error is encountered.
°dONLNd‡JVÇ*0Further Reference: u4u
˘°dONLNdÛW*c.+

•°dONLNdıW<cç)Inside Macintosh°dONLNdWçc
u)Q-, Volume II-145 & V-410, The Printing Manager°dONLNd3c*o.(ãH
•°dONLNd5c<o˛)$Technical Note M.IM.DevIndPrinting —°dONLNd\o`{Í+$ Device-Independent Printing°dONLNdy{*á.(£H
•°dONLNd{{<ás)
d e v e l o p°dONLNdà{sá
-)7&, July 1990, Issue 3, “Meet PrGeneral” ∂4∂
˘

(Œ612)
 of 12(Œ
Z#PR 10 - A Printing Loop That Cares…+YM.PR.PrintLoopˇ